diff --git a/wally-pipelined/src/fpu/FMA/align.sv b/wally-pipelined/src/fpu/FMA/align.sv index 68e755cd..dbe9474f 100644 --- a/wally-pipelined/src/fpu/FMA/align.sv +++ b/wally-pipelined/src/fpu/FMA/align.sv @@ -56,7 +56,7 @@ module align(zman, ae, aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, t, bs // addend on right shifts. Handle special cases of shifting // by too much. - always @(z2 or aligncnt or zzero or xzero or yzero or zdenorm or proddenorm) + always @(aligncnt or zman or zdenorm) begin // Default to clearing sticky bits @@ -108,9 +108,9 @@ module align(zman, ae, aligncnt, xzero, yzero, zzero, zdenorm, proddenorm, t, bs // use some behavioral code to find sticky bit. This is really // done by hardware in the shifter. - if (aligncnt < 0) - for (i=0; i<-aligncnt-52; i = i+1) - bs = bs || z2[i]; + //if (aligncnt < 0) + // for (i=0; i<-aligncnt-52; i = i+1) + // bs = bs || z2[i]; end end diff --git a/wally-pipelined/src/fpu/FMA/normalize.sv b/wally-pipelined/src/fpu/FMA/normalize.sv index cb9a15de..5e7a4125 100644 --- a/wally-pipelined/src/fpu/FMA/normalize.sv +++ b/wally-pipelined/src/fpu/FMA/normalize.sv @@ -61,7 +61,7 @@ logic tmp,tmp1,tmp2,tmp3; // does not require a true subtraction shown in the model. assign tmp = ($signed(ae-normcnt+2) >= $signed(-1022)); - always @(sum or normcnt or sumshift or ae or aligncnt) + always @(sum or sumshift or ae or aligncnt or normcnt or bs or zexp or zdenorm) begin // d = aligncnt // l = normcnt @@ -106,11 +106,16 @@ logic tmp,tmp1,tmp2,tmp3; v = sumshifted[161:108]; sticky = (|sumshifted[107:0]) | bs; de0 = zexp+1; - end else begin + end else if (sumshifted[161]) begin v = sumshifted[160:107]; sticky = (|sumshifted[106:0]) | bs; //de0 = zexp-1; de0 = zexp; + end else begin + v = sumshifted[159:106]; + sticky = (|sumshifted[105:0]) | bs; + //de0 = zexp-1; + de0 = zexp-1; end resultdenorm = 0; diff --git a/wally-pipelined/src/fpu/FMA/tbgen/results.dat b/wally-pipelined/src/fpu/FMA/tbgen/results.dat index 3d57d286..c95e7771 100644 --- a/wally-pipelined/src/fpu/FMA/tbgen/results.dat +++ b/wally-pipelined/src/fpu/FMA/tbgen/results.dat @@ -1,66 +1,11 @@ -3feffff77fffffff bfc0003fffffffbe 40200000fffbffff 402fc00010fc4400 401f800021f88800 Wrong 94657 -0010000000000000 7fe0000000000000 c340000000000000 c34fffffffffffff c33ffffffffffffe Wrong 308141 8020007ffdffffff 9beffff7fff7fffe 000ffffffff7fffe 0000000000000000 000ffffffff7fffe Wrong zdenorm unflw 475303 -3ed03feffffffffe bf1ffbfff7fffffe 3fd000000000037e 3fdfffffff7e143e 3fcffffffefc287c Wrong 535723 -3fb0ffffffffffff 407000000fffffbf c0f00000000800fe c0fffef00006f0fe c0effde0000de1fc Wrong 632395 3cafffffffffffff 3fd0000000000000 3cafffffffffffff 3c8ffffffffffffb 3cb3ffffffffffff Wrong 706913 -37ffc3cd8026eda0 bfe0000000000000 beab43550afc66d5 bea0000000000000 beab43550afc66d5 Wrong 745179 -bfd000080000000f b7e1fbffffffffff b800200000003ffe b80f003f70203ffd b7fe007ee0407ffa Wrong 771361 -3fd0000000000000 bfd0000000000001 3ff0000000000001 3fff000000000001 3fee000000000002 Wrong 882131 -3fd0000000000001 c000000000000000 4340000000000000 4350000000000000 433fffffffffffff Wrong 960677 -3fdffffffffffffe c01ffffffffffffe 4340000000000000 434ffffffffffffe 433ffffffffffffc Wrong 1105685 -c34ffefe00000000 bc4feffffffffffd c020000000000087 c02fe011017f0087 c01fc02202fe010e Wrong 1182217 -3fe0000000000001 3fd0000000000001 bff0000000000001 bffe000000000001 bfec000000000001 Wrong 1196315 -3fefffffffffffff 4000000000000000 c340000000000000 c34fffffffffffff c33ffffffffffffe Wrong 1274861 -3ff0000000000000 401ffffffffffffe c340000000000000 c34ffffffffffffc c33ffffffffffff8 Wrong 1419869 -3ff0000000000000 bfefffffffffffff 4340000000000000 4350000000000000 433fffffffffffff Wrong 1444037 -3fffffffffffffff c000000000000001 4340000000000000 434ffffffffffffe 433ffffffffffffc Wrong 1589045 bfbfffff007fffff 000fffffffffffff 000bffffffc00000 0015000007dc0000 000a00000fb80000 Wrong ydenorm zdenorm 1675647 -4000000000000001 3fefffffffffffff c340000000000000 c34fffffffffffff c33ffffffffffffe Wrong 1758221 -400ffffffffffffe 4000000000000001 c340000000000000 c34ffffffffffffc c33ffffffffffff8 Wrong 1903229 -400ffffffffffffe bfd0000000000000 4340000000000000 4350000000000000 433fffffffffffff Wrong 1927397 -4010000000000000 bca0000000000000 3ff0000000000001 3fffffffffffffff 3feffffffffffffe Wrong 1993859 -4010000000000001 bfeffffffffffffe 4340000000000000 434ffffffffffffe 433ffffffffffffc Wrong 2072405 -401ffffffffffffe c00fffffffffffff 4340000000000000 434ffffffffffff0 433fffffffffffe0 Wrong 2217413 00114508bde544e1 3caffffffffffffe 800010000003fffe 801008000001fffe 800010000003fffd Wrong zdenorm 2310057 -3f8b17d321454789 3fd7ffffffffff7f bfe000080ffffffe bfefd764534e1814 bfdfaec8a69c3027 Wrong 2318113 -ca7fff0000000fff 3ca62fd739ece5a5 48000000003f0000 480fff4e87112667 47fffe9d0e224cce Wrong 2348323 -c34ffffffffffc00 bbe000000000027f 43dfffffeffffbff 43d487c0c983e604 43dfffffeffffbff Wrong 2469163 800ffffffdffffff bfcffe00003ffffe 800ffff01ffffffe 80160018103bfbff 800c00302077f7ff Wrong xdenorm zdenorm 2475205 -401ffffffbfffbff 3fbfffef80000000 c00000400000007f c0080044210000fb bff00088420001f6 Wrong 2493331 -7feffffffffffffe 001fffffffffffff c340000000000000 c34ffffffffffffc c33ffffffffffff8 Wrong 2724941 -bfdfffe00fffffff 3fccf2165e6eea40 3ff0000023fffffe 3ffe30e08c52e68e 3fec61c118a5cd1c Wrong 2880019 -c090003ffffffffb 3fefffffffffffff 41d00000003ffe00 41dfffff003bfe00 41cffffe0077fc00 Wrong 3222399 -3fcffffffff7ff7f bff4691aa0d59fcd 40600007ffe00000 406ff5d3728f97bd 405feba6e51f2f7b Wrong 3260665 -8010000000000000 7fefffffffffffff 4340000000000000 434ffffffffffffe 433ffffffffffffc Wrong 3377477 -3fbfffffefbfffff 3f600001ff7ffffe bfc000fffffffffe bfcff8ffff044fff bfbff1fffe089ffd Wrong 3417757 bcafffffffffffff 3fd0000000000001 bcafffffffffffff bc8ffffffffffffd bcb4000000000000 Wrong 3776249 -bcafffffffffffff 3ff0000000000001 3ff0000000000001 4000000000000000 3ff0000000000000 Wrong 3782291 bfc0000000800008 43d0001000000002 c3cffffbffff8000 c3a00000007e008a c3d20000000fc011 Wrong 3804445 -bcaffffffffffffe 4340000000000000 4340000000000000 434fffffffffffff 433ffffffffffffe Wrong 3860837 -bfd0000000000000 bfdfffffffffffff bff0000000000001 bffe000000000001 bfec000000000002 Wrong 3951467 -bfd0000000000001 c000000000000001 c340000000000000 c350000000000000 c33fffffffffffff Wrong 4030013 -3f3e007ffffffffe bfe0000000000000 3ff0000000001f7f 3fffff0ffc001f7f 3feffe1ff8003efe Wrong 4092447 -c070000000024000 c01ffffffffffffe c1e0000004003ffe c1efffff04003ffe c1dffffe08007ffc Wrong 4104531 -4bb000040000003e 318ffffffffff7ff bfe0000000000017 bfeffffffffff817 bfdffffffffff02e Wrong 4209259 -bfe0000000000001 3fdffffffffffffe 3ff0000000000001 3ffc000000000001 3fe8000000000002 Wrong 4265651 bfefffffffffffff 3fefffffffffffff bff0000000000001 b950000000000000 c000000000000000 Wrong 4338155 -bfefffffffffffff 400fffffffffffff 4340000000000000 434ffffffffffffe 433ffffffffffffc Wrong 4344197 -bff0000000000000 bfeffffffffffffe c340000000000000 c350000000000000 c33fffffffffffff Wrong 4513373 -bfffffffffffffff c00fffffffffffff c340000000000000 c34ffffffffffffc c33ffffffffffff8 Wrong 4658381 -400ffffffffffd7f c000000000000001 c013fffffdffffff c027fffffffffec1 c029fffffefffec0 Wrong 4726857 -c000000000000000 3ca0000000000001 3ff0000000000001 4000000000000000 3ff0000000000000 Wrong 4749011 -3fe0000000000027 bfffffffffffff77 40600001ffffdfff 406fe001ffffdfff 405fc003ffffbffe Wrong 4777207 -c000000000000001 3ff0000000000000 4340000000000000 434fffffffffffff 433ffffffffffffe Wrong 4827557 -c00ffffffffffffe 400ffffffffffffe 4340000000000000 434ffffffffffff8 433ffffffffffff0 Wrong 4972565 -c00ffffffffffffe bfd0000000000001 c340000000000000 c350000000000000 c33fffffffffffff Wrong 4996733 -c010000000000000 bca0000000000001 bff0000000000001 bfffffffffffffff bfeffffffffffffe Wrong 5063195 -c010000000000001 bff0000000000000 c340000000000000 c34ffffffffffffe c33ffffffffffffc Wrong 5141741 37ea3353806450ba bffffffffffffffe b803fffffffff7ff b7c19a9c032205b3 b8108cd4e019102e Wrong 5143755 -bf1fffffe0ffffff bfcffffffbffff00 bf9000001ffffc00 bf9ff8002008bc00 bf8ff00040117800 Wrong 5236399 8010000000803fff 3ff0000000000001 000fffe07fffffff fff0000000000000 8000001f80804001 Wrong zdenorm w=-inf 5246469 -41cdffffc0000000 bfbff87ffffffffe 41c000000080ffff 41cc40e1087f1fff 41b881c210fe3ffe Wrong 5278693 -c01ffffffffffffe c00ffffffffffffe c340000000000000 c34ffffffffffff0 c33fffffffffffe0 Wrong 5286749 -ffe0000000000001 0000000000000001 4340000000000000 4350000000000000 4340000000000000 Wrong ydenorm 5649269 b7fffff80000001f 001ffffffffffffe 800fffffffff07ff 8000000000000000 800fffffffff07ff Wrong w=-zero zdenorm unflw 5723787 -bfcc03a8225fe071 ffeffffffffffffe ffe0000420000000 ffe8ff1a176807e4 ffd1fe342ed00fc8 Wrong 5923173 diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb b/wally-pipelined/src/fpu/FMA/tbgen/tb index fbc8c3ff..1e06e99b 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 26625432..a55d8023 100644 --- a/wally-pipelined/src/fpu/FMA/tbgen/tb.c +++ b/wally-pipelined/src/fpu/FMA/tbgen/tb.c @@ -26,7 +26,7 @@ void main() { char ans[81]; char flags[3]; int rn,rz,rm,rp; - long stop = 6015817; + long stop = 5723787; int debug = 1; //my_string = (char *) malloc (nbytes + 1); //bytes_read = getline (&my_string, &nbytes, stdin); diff --git a/wally-pipelined/src/fpu/FMA/tbgen/tb.v b/wally-pipelined/src/fpu/FMA/tbgen/tb.v index 2762ffe8..1c9b75dd 100644 --- a/wally-pipelined/src/fpu/FMA/tbgen/tb.v +++ b/wally-pipelined/src/fpu/FMA/tbgen/tb.v @@ -133612,6821 +133612,6 @@ initial 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"); - end - x = 64'h3FDFFFFF0000000F; - y = 64'hF540000000EFFFFE; - z = 64'h4954D5A68860848B; - ans = 64'hF52FFFFF01DFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5725801\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3FD0000000000000; - 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,"5727815\n"); - end - x = 64'h3FDFFFFF80007FFF; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h402001FFFFFFFFE0; - ans = 64'h402081FFFE0001E0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5729829\n"); - end - x = 64'h3EB17B46105C029E; - y = 64'h356FFFF80007FFFF; - z = 64'hBFCFFFFFE0001FFE; - ans = 64'hBFCFFFFFE0001FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5731843\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'h3FF0000000000000; - z = 64'h3CAFFFFFFFFFFFFF; - 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,"5733857\n"); - end - x = 64'h43F008000000003E; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'hC3DC8B92C412FD96; - ans = 64'h43F8ED1B4EFB4115; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5735871\n"); - end - x = 64'hC1E6DAF608F120DA; - y = 64'hBFDF9FA3B892B56B; - z = 64'hB7E07FFFFFFFC000; - ans = 64'h41D696233E4F12C4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5737885\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'h400FFFFFFFFFFFFE; - 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,"5739899\n"); - end - x = 64'h181040003FFFFFFE; - y = 64'h401FFFFFFFFFFFFF; - z = 64'hFFF000000003FDFF; - ans = 64'hFFF800000003FDFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5741913\n"); - end - x = 64'h7FD4100000000000; - y = 64'hBF2FFFFE03FFFFFE; - z = 64'h9E4F275405EB089B; - ans = 64'hFF140FFEC181FFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5743927\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'h434FFFFFFFFFFFFE; - 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,"5745941\n"); - end - x = 64'hC7E000004000FFFE; - y = 64'h7FE0000000000001; - z = 64'hC3FFFFFFFAFFFFFE; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5747955\n"); - end - x = 64'h434FFF7FFF7FFFFF; - y = 64'hC1DFFFF800000004; - z = 64'h8020081FFFFFFFFF; - ans = 64'hC53FFF77FFA00023; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5749969\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'h7FFFFFFFFFFFFFFF; - 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,"5751983\n"); - end - x = 64'h3FADCDBDD2C3F87E; - y = 64'h8000000000000001; - z = 64'h402FFFFFFFE00007; - ans = 64'h402FFFFFFFE00007; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5753997\n"); - end - x = 64'h29F0000000FC0000; - y = 64'h400FFFFFBFFFFFF8; - z = 64'h3FB000007FFFFDFE; - ans = 64'h3FB000007FFFFDFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5756011\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'h801FFFFFFFFFFFFF; - z = 64'hBCAFFFFFFFFFFFFF; - 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,"5758025\n"); - end - x = 64'h3FEFFFFFF07FFFFE; - y = 64'hBCA0000000000001; - z = 64'h43FC00000000001F; - ans = 64'h43FC00000000001F; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5760039\n"); - end - x = 64'h7663FFFFFFFFFEFF; - y = 64'hBD15811360CCDAF7; - z = 64'hCFA00C0000000000; - ans = 64'hF38AE1583900105B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5762053\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBFDFFFFFFFFFFFFF; - 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,"5764067\n"); - end - x = 64'hC3600FFFFFFFF800; - y = 64'hBFE0000000000000; - z = 64'h3FF2000000000002; - ans = 64'h43500FFFFFFFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5766081\n"); - end - x = 64'h32CFFFFFFE00007E; - y = 64'hC8050243362E2BDE; - z = 64'hC1DFFFFFFFFFFFF7; - ans = 64'hC1DFFFFFFFFFFFF7; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5768095\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'hBFF0000000000001; - 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,"5770109\n"); - end - x = 64'h47FFDC0000000000; - y = 64'hC000000000000000; - z = 64'hBFD0000040FFFFFE; - ans = 64'hC80FDC0000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5772123\n"); - end - x = 64'h40013FAD9F4E14D4; - y = 64'h8027FFFFFFFF0000; - z = 64'h3FCFFFF800003FFE; - ans = 64'h3FCFFFF800003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5774137\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'hC010000000000001; - 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,"5776151\n"); - end - x = 64'hBFE00080003FFFFF; - y = 64'hC340000000000000; - z = 64'h8400000007FFFBFF; - ans = 64'h43300080003FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5778165\n"); - end - x = 64'hC2A6388522E64A23; - y = 64'h7FDFFFFFFFFFE003; - z = 64'h42FFFFFF80000003; - ans = 64'hFFF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5780179\n"); - end - x = 64'hFFEFFFFFFFFFFFFF; - y = 64'hFFE0000000000001; - 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,"5782193\n"); - end - x = 64'hC7E7482505475B5A; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hC0E000007FFDFFFF; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5784207\n"); - end - x = 64'h3FD0000401FFFFFF; - y = 64'hC07FFFE000007FFF; - z = 64'h3FAFC000001FFFFF; - ans = 64'hC05FFBF003F877FD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5786221\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - 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,"5788235\n"); - end - x = 64'hBF8EE3C2E139EE27; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hC8F0000000407FFF; - ans = 64'hC8F0000000407FFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5790249\n"); - end - x = 64'hC28FFBFFFFFFFFF7; - y = 64'hB818000000010000; - z = 64'h4210002400000000; - ans = 64'h4210002400000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5792263\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3CA0000000000000; - z = 64'h4340000000000000; - 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,"5794277\n"); - end - x = 64'h3F90000000003EFF; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h41DFFFFF88000000; - ans = 64'h41DFFFFF88000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5796291\n"); - end - x = 64'hBDA0040003FFFFFE; - y = 64'hC0CFFDFFFEFFFFFF; - z = 64'h421FFFEFFFFFFE00; - ans = 64'h421FFFEFFFFFFE00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5798305\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - 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,"5800319\n"); - end - x = 64'h43FFFDFFFFFFFFC0; - y = 64'h3FEFFFFFFFFFFFFF; - z = 64'h3FFFC00000003FFF; - ans = 64'h43FFFDFFFFFFFFBF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5802333\n"); - end - x = 64'h32AFF00000007FFE; - y = 64'hC3D002FFFFFFFFFE; - z = 64'hC0335D8614472428; - ans = 64'hC0335D8614472428; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5804347\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'h3FFFFFFFFFFFFFFE; - 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,"5806361\n"); - end - x = 64'hC398D85ACA9EFF71; - y = 64'h400FFFFFFFFFFFFF; - z = 64'h41E5FAB80EF2D73E; - ans = 64'hC3B8D85AC9EF29B0; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5808375\n"); - end - x = 64'hC7FE32B29E0C01BB; - y = 64'hBCA1C0817C2C7D4B; - z = 64'h3F367CCD682F6C74; - ans = 64'h44B0C0994539262D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5810389\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'h401FFFFFFFFFFFFE; - 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,"5812403\n"); - end - x = 64'hCE8F000000007FFF; - y = 64'h4340000000000001; - z = 64'hBFE0001FFFFFF800; - ans = 64'hD1DF000000008001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5814417\n"); - end - x = 64'h1D3FDFFFFFFDFFFF; - y = 64'hC1C0000020000004; - z = 64'hC01FFFF800003FFE; - ans = 64'hC01FFFF800003FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5816431\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'h7FEFFFFFFFFFFFFF; - 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,"5818445\n"); - end - x = 64'h41F00020003FFFFE; - y = 64'h7FF0000000000001; - z = 64'h4340000000FFFFFF; - 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,"5820459\n"); - end - x = 64'h3CDFFFFFBFFF7FFF; - y = 64'hFFF1FFFFFFFFFBFE; - z = 64'h40300FFDFFFFFFFF; - ans = 64'hFFF9FFFFFFFFFBFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5822473\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - 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,"5824487\n"); - end - x = 64'hB80FFFFFFF7F7FFF; - y = 64'h8010000000000001; - z = 64'hBF9FFFFFC00000FF; - ans = 64'hBF9FFFFFC00000FF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5826501\n"); - end - x = 64'hC060000000800003; - y = 64'hEBAFFFFFFE01FFFF; - z = 64'h7FFF7FFFFFC00000; - ans = 64'h7FFF7FFFFFC00000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5828515\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBCAFFFFFFFFFFFFF; - z = 64'h3CAFFFFFFFFFFFFF; - 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,"5830529\n"); - end - x = 64'hBF1FFFFF8003FFFF; - y = 64'hBFD0000000000000; - z = 64'hC220800004000000; - ans = 64'hC220800003FFFFFC; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5832543\n"); - end - x = 64'h3CA4AB8A15BB86C3; - y = 64'hC06FFFFFFFFFFFD0; - z = 64'h327000000001FEFE; - ans = 64'hBD24AB8A15BB86A4; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5834557\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'hBFE0000000000001; - z = 64'hBFF0000000000001; - 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,"5836571\n"); - end - x = 64'h00000000000003BF; - y = 64'hBFF0000000000000; - z = 64'h0EBFFFFEFFFFFEFE; - ans = 64'h0EBFFFFEFFFFFEFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5838585\n"); - end - x = 64'h3FBFFFFFFF000008; - y = 64'h401B0AD152F3EB32; - z = 64'hBABFBFFFFDFFFFFF; - ans = 64'h3FEB0AD1521B94AE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5840599\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC000000000000001; - 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,"5842613\n"); - end - x = 64'h3812031359E6B20B; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hB7F02000000003FF; - ans = 64'hB833051359E6B24A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5844627\n"); - end - x = 64'h406FFFFDFFFFFFFD; - y = 64'h3F3FFFF800000800; - z = 64'h47F000041FFFFFFF; - ans = 64'h47F000041FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5846641\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'hC340000000000000; - 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,"5848655\n"); - end - x = 64'hFFF0800000002000; - y = 64'hC34FFFFFFFFFFFFE; - z = 64'h400FFFFFFFF1FFFF; - ans = 64'hFFF8800000002000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5850669\n"); - end - x = 64'h3F700200001FFFFF; - y = 64'h000FFFFFFFE003FF; - z = 64'h4001141A11550897; - ans = 64'h4001141A11550897; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5852683\n"); - end - x = 64'hFFEFFFFFFFFFFFFE; - y = 64'hFFF0000000000000; - 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,"5854697\n"); - end - x = 64'h41FFFC00000FFFFF; - y = 64'hFFFFFFFFFFFFFFFE; - z = 64'hC021FFFC00000000; - 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,"5856711\n"); - end - x = 64'hC1CFFFFFFF7FFFFE; - y = 64'hBFAF0E5FF2AC719C; - z = 64'h41F89242D54A35B2; - ans = 64'h41F8D05F952E9622; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5858725\n"); - end - x = 64'hFFF0000000000000; - y = 64'h0010000000000000; - 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,"5860739\n"); - end - x = 64'hB81FFFDFF8000000; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h406FFFFFFFF9FFFE; - ans = 64'h406FFFFFFFF9FFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5862753\n"); - end - x = 64'hBFFFFFFFFFBFFFBE; - y = 64'h3FF0400003FFFFFE; - z = 64'h417DD4E89ED4C2A5; - ans = 64'h417DD4E87E54C29D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5864767\n"); - end - x = 64'hFFF0000000000000; - y = 64'h3CAFFFFFFFFFFFFE; - 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,"5866781\n"); - end - x = 64'h37E037AD784678E1; - y = 64'h3FDFFFFFFFFFFFFF; - z = 64'hB7E000000000103F; - ans = 64'hB7CF90A50F734F3B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5868795\n"); - end - x = 64'hC2700007FFFFFE00; - y = 64'h415FFFFFE0000003; - z = 64'hC34FFFFFFFFF7DFF; - ans = 64'hC3E00807EFFFF5E1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5870809\n"); - end - x = 64'hFFF0000000000000; - y = 64'h3FEFFFFFFFFFFFFE; - 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,"5872823\n"); - end - x = 64'h43D000000800FFFE; - y = 64'h3FFFFFFFFFFFFFFF; - z = 64'h800203B450AC509D; - ans = 64'h43E000000800FFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5874837\n"); - end - x = 64'hC01000001FFFC000; - y = 64'hC1E00000FFFE0000; - z = 64'hCF67FFE000000000; - ans = 64'hCF67FFE000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5876851\n"); - end - x = 64'hFFF0000000000000; - y = 64'h400FFFFFFFFFFFFE; - 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,"5878865\n"); - end - x = 64'hB8100000000000F6; - y = 64'h4010000000000001; - z = 64'h400FFDFEFFFFFFFF; - ans = 64'h400FFDFEFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5880879\n"); - end - x = 64'h3D80001000000800; - y = 64'h43CFFFFE0000007F; - z = 64'hFFDD733B37E3B984; - ans = 64'hFFDD733B37E3B984; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5882893\n"); - end - x = 64'hFFF0000000000000; - y = 64'h434FFFFFFFFFFFFF; - 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,"5884907\n"); - end - x = 64'h2E9CF09323D2C868; - y = 64'h7FE0000000000001; - z = 64'h40F0040000000001; - ans = 64'h6E8CF09323D2C86A; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5886921\n"); - end - x = 64'h40E0080000007FFE; - y = 64'hBC5F3FFFFFFFFFFF; - z = 64'h7FF0000000000FFD; - ans = 64'h7FF8000000000FFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5888935\n"); - end - x = 64'hFFF0000000000000; - y = 64'h7FFFFFFFFFFFFFFF; - 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,"5890949\n"); - end - x = 64'h001FFF00000003FF; - y = 64'h8000000000000000; - z = 64'hC7E0003FFFFFFFFD; - ans = 64'hC7E0003FFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5892963\n"); - end - x = 64'h41EFFFC0001FFFFE; - y = 64'h8011966EF940AF75; - z = 64'h43C200FFFFFFFFFF; - ans = 64'h43C200FFFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5894977\n"); - end - x = 64'hFFF0000000000000; - y = 64'h8010000000000001; - 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,"5896991\n"); - end - x = 64'hC0800000080007FE; - y = 64'hBCA0000000000000; - z = 64'hC0DFFFFFFFE001FE; - ans = 64'hC0DFFFFFFFE001FE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5899005\n"); - end - x = 64'hFFF00FFFFFFFFFFE; - y = 64'hB6600000000001FC; - z = 64'hBFC03FFFFFFFFFFB; - ans = 64'hFFF80FFFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5901019\n"); - end - x = 64'hFFF0000000000000; - y = 64'hBFD0000000000001; - 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,"5903033\n"); - end - x = 64'hC3EFFFFFFFFFF800; - y = 64'hBFE0000000000000; - z = 64'hBFE08000000003FF; - ans = 64'h43DFFFFFFFFFF800; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5905047\n"); - end - x = 64'h279FFFBFFFDFFFFF; - y = 64'hC1F00007E0000000; - z = 64'h47F5D4BEBAF82AC1; - ans = 64'h47F5D4BEBAF82AC1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5907061\n"); - end - x = 64'hFFF0000000000000; - y = 64'hBFF0000000000001; - 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,"5909075\n"); - end - x = 64'hBFD232E8A1642C84; - y = 64'hBFFFFFFFFFFFFFFE; - z = 64'hB7E47FFFFFFFFFFF; - ans = 64'h3FE232E8A1642C83; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5911089\n"); - end - x = 64'h3FC00002003FFFFE; - y = 64'hC7FFFFFFFFFFFFFF; - z = 64'h3FF86FF487DDC560; - ans = 64'hC7D00002003FFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5913103\n"); - end - x = 64'hFFF0000000000000; - y = 64'hC010000000000000; - 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,"5915117\n"); - end - x = 64'hB953FFFBFFFFFFFF; - y = 64'hC01FFFFFFFFFFFFE; - z = 64'h43EFFFFFFBFBFFFF; - ans = 64'h43EFFFFFFBFBFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5917131\n"); - end - x = 64'hC3400145919FB114; - y = 64'hB7FFFFFFFFFFFFD0; - z = 64'hC1800000807FFFFF; - ans = 64'hC1800000807FFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5919145\n"); - end - x = 64'hFFF0000000000000; - y = 64'hFFE0000000000000; - 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,"5921159\n"); - end - x = 64'hBFCC03A8225FE071; - y = 64'hFFEFFFFFFFFFFFFE; - z = 64'hFFE0000420000000; - ans = 64'hFFD1FE342ED00FC8; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5923173\n"); - end - x = 64'hB07EB39219723C6C; - y = 64'hBCA0000000080002; - z = 64'hB7FEF7A6994454C9; - ans = 64'hB7FEF7A6994454C9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5925187\n"); - end - x = 64'hFFF0000000000001; - y = 64'h0000000000000000; - 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,"5927201\n"); - end - x = 64'h3FB8CFDF5B77451D; - y = 64'h000FFFFFFFFFFFFF; - z = 64'hC03FEFEFFFFFFFFE; - ans = 64'hC03FEFEFFFFFFFFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5929215\n"); - end - x = 64'hBF6000002007FFFF; - y = 64'hB818EC6A605F44E1; - z = 64'hC3EFFFFBFFFF8000; - ans = 64'hC3EFFFFBFFFF8000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5931229\n"); - end - x = 64'hFFF0000000000001; - y = 64'h001FFFFFFFFFFFFE; - 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,"5933243\n"); - end - x = 64'hC050000003FFF000; - y = 64'h3CAFFFFFFFFFFFFF; - z = 64'h402FFFFFFFFFFDF7; - ans = 64'h402FFFFFFFFFFDEF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5935257\n"); - end - x = 64'h3EB9C788BAFD1C8D; - y = 64'hC3CFBFFFEFFFFFFF; - z = 64'h4011FFFFFFFFFF7F; - ans = 64'hC29993F99CA34BF6; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5937271\n"); - end - x = 64'hFFF0000000000001; - y = 64'h3FDFFFFFFFFFFFFE; - z = 64'h4340000000000000; - 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,"5939285\n"); - end - x = 64'hC0300000BFFFFFFF; - y = 64'h3FE0000000000001; - z = 64'h401FFFFFE0400000; - ans = 64'hBED9FC0000000001; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5941299\n"); - end - x = 64'hC3FFFFFFF81FFFFF; - y = 64'h4008000000001FFF; - z = 64'h3FFFFFFFFFFDFFDF; - ans = 64'hC417FFFFFA181FFE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5943313\n"); - end - x = 64'hFFF0000000000001; - y = 64'h3FFFFFFFFFFFFFFF; - 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,"5945327\n"); - end - x = 64'h7FF000000003FFBE; - y = 64'h4000000000000001; - z = 64'hB8F000000001FFFF; - ans = 64'h7FF800000003FFBE; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5947341\n"); - end - x = 64'hBF90348F17F835B5; - y = 64'h380FFFFFFFFC001E; - z = 64'h3FEFFF7DFFFFFFFF; - ans = 64'h3FEFFF7DFFFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5949355\n"); - end - x = 64'hFFF0000000000001; - y = 64'h401FFFFFFFFFFFFF; - 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,"5951369\n"); - end - x = 64'hBFFFFFFFFFF7DFFF; - y = 64'h4340000000000001; - z = 64'h4A4100000000007E; - ans = 64'h4A4100000000007E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5953383\n"); - end - x = 64'hDD32C11CF81B2B12; - y = 64'h40002B8C7D146FAD; - z = 64'hC021ABBFD858AA44; - ans = 64'hDD42F428A25015A1; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5955397\n"); - end - x = 64'hFFF0000000000001; - y = 64'h7FEFFFFFFFFFFFFF; - z = 64'h3FF0000000000001; - 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,"5957411\n"); - end - x = 64'h3CA82283A63E6AB4; - y = 64'h7FF0000000000000; - z = 64'hBFCFFFFFFFBFFF7E; - ans = 64'h7FF0000000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5959425\n"); - end - x = 64'h41C0000000800080; - y = 64'h40F0002FFFFFFFFF; - z = 64'h43FA043FA875191B; - ans = 64'h43FA0441A87B192B; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5961439\n"); - end - x = 64'hFFF0000000000001; - y = 64'h8000000000000001; - 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,"5963453\n"); - end - x = 64'h40BE7ECF4232F5E2; - y = 64'h8010000000000000; - z = 64'hBFE803DBDDF1709C; - ans = 64'hBFE803DBDDF1709C; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5965467\n"); - end - x = 64'h43301FFFFFFFFFFF; - y = 64'hBD2FFFFFFEFDFFFF; - z = 64'hC0594B450D492733; - ans = 64'hC07672D142D047CB; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5967481\n"); - end - x = 64'hFFF0000000000001; - y = 64'hBCA0000000000001; - 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,"5969495\n"); - end - x = 64'h3FE0188BB8C96308; - y = 64'hBFD0000000000000; - z = 64'hBFC0000007FFFF7F; - ans = 64'hBFD00C45E064B144; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5971509\n"); - end - x = 64'hC3C85A0DF879140D; - y = 64'h40101000000FFFFF; - z = 64'h3FD0CEF3C3838CBD; - ans = 64'hC3E872680689E72D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5973523\n"); - end - x = 64'hFFF0000000000001; - y = 64'hBFE0000000000001; - 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,"5975537\n"); - end - x = 64'hC8BFFFF5FFFFFFFF; - y = 64'hBFEFFFFFFFFFFFFE; - z = 64'h000000000002FFFF; - ans = 64'h48BFFFF5FFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5977551\n"); - end - x = 64'h801FFFFFFFE001FF; - y = 64'hB91000001000000E; - z = 64'hD05000401FFFFFFF; - ans = 64'hD05000401FFFFFFF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5979565\n"); - end - x = 64'hFFF0000000000001; - y = 64'hC000000000000000; - 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,"5981579\n"); - end - x = 64'h434FFFFFC000000F; - y = 64'hC00FFFFFFFFFFFFE; - z = 64'hBFD6822EBCAA6420; - ans = 64'hC36FFFFFC000000D; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5983593\n"); - end - x = 64'hE420000104000000; - y = 64'hC01177E378AD2AB5; - z = 64'h40640003FFFFFFFF; - ans = 64'h644177E494895B1E; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5985607\n"); - end - x = 64'hFFF0000000000001; - y = 64'hC340000000000000; - z = 64'h4340000000000000; - 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,"5987621\n"); - end - x = 64'h4010000000400001; - y = 64'hC34FFFFFFFFFFFFF; - z = 64'hB7EF7FFFFFFFFBFE; - ans = 64'hC370000000400000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5989635\n"); - end - x = 64'h3FFFFFFFBFFFFFBE; - y = 64'h3FBFFFC0000FFFFF; - z = 64'hFFE0002000000000; - ans = 64'hFFE0002000000000; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5991649\n"); - end - x = 64'hFFF0000000000001; - y = 64'hFFEFFFFFFFFFFFFE; - 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,"5993663\n"); - end - x = 64'h43FFFF0000000002; - y = 64'hFFFFFFFFFFFFFFFF; - z = 64'h4F0FFFFFFFFFFE80; - 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,"5995677\n"); - end - x = 64'hBFDFFE0001FFFFFE; - y = 64'h31F8000000200000; - z = 64'h37EAD068BEBDB0D3; - ans = 64'h37EAD068BEBDB0D3; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"5997691\n"); - end - x = 64'hFFFFFFFFFFFFFFFF; - y = 64'h000FFFFFFFFFFFFE; - z = 64'hBCAFFFFFFFFFFFFF; - 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,"5999705\n"); - end - x = 64'hC03BFFFFFFFFBFFE; - y = 64'h001FFFFFFFFFFFFF; - z = 64'h37F5669D69074178; - ans = 64'h37F5669D69074178; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6001719\n"); - end - x = 64'h41CFFFFFFFFFDFEE; - y = 64'hD6B0004000000002; - z = 64'hBFFFFF7FFFFFFFFF; - ans = 64'hD890003FFFFFEFF9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6003733\n"); - end - x = 64'hFFFFFFFFFFFFFFFF; - y = 64'h3CAFFFFFFFFFFFFE; - z = 64'h3FF0000000000001; - 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,"6005747\n"); - end - x = 64'h4000007FFFFFDFFF; - y = 64'h3FD0000000000001; - z = 64'h4010100000010000; - ans = 64'h401210100000FC00; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6007761\n"); - end - x = 64'h00140FFFFFFFFFFF; - y = 64'h37E0B8D4B56FDDE5; - z = 64'h480FFDFFFFFFFFDF; - ans = 64'h480FFDFFFFFFFFDF; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6009775\n"); - end - x = 64'hFFFFFFFFFFFFFFFF; - y = 64'h3FEFFFFFFFFFFFFF; - 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,"6011789\n"); - end - x = 64'h00020000003FFFFF; - y = 64'h3FF0000000000001; - z = 64'h4000007FFFFFFFFD; - ans = 64'h4000007FFFFFFFFD; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6013803\n"); - end - x = 64'h3FF00000100003FF; - y = 64'h404FFE00000003FE; - z = 64'hC30B1272065FD0C9; - ans = 64'hC30B1272065FCEC9; - rn = 1; - rz = 0; - rm = 0; - rp = 0; - earlyres = 64'b0; - earlyressel = 0; - bypsel= 2'b0; - bypplus1 = 0; - byppostnorm = 0; -#10 - // IEEE 754-2008 section 6.3 states: "When ether an input or result is NaN, this - // standard does not interpret the sign of a NaN." - wnan = &w[62:52] && |w[51:0]; - xnan = &x[62:52] && |x[51:0]; - ynan = &y[62:52] && |y[51:0]; - znan = &z[62:52] && |z[51:0]; - ansnan = &ans[62:52] && |ans[51:0]; - xnorm = ~(|x[62:52]) && |x[51:0] ? {x[50:0], 1'b0} : x; - ynorm = ~(|y[62:52]) && |y[51:0] ? {y[50:0], 1'b0} : y; - s = ({54'b1,xnorm} + (bypsel && bypplus1)) * {54'b1,ynorm}; - if((!wnan && (w != ans)) || (wnan && ansnan && ~(((xnan && (w[62:0] == {x[62:52],1'b1,x[50:0]})) || (ynan && (w[62:0] == {y[62:52],1'b1,y[50:0]})) || (znan && (w[62:0] == {z[62:52],1'b1,z[50:0]})) || (w[62:0] == ans[62:0])) ))) begin - $fwrite(fp, "%h %h %h %h %h Wrong ",x,y, z, w, ans); - if(w == 64'h8000000000000000) $fwrite(fp, "w=-zero "); - if(~(|x[62:52]) && |x[51:0]) $fwrite(fp, "xdenorm "); - if(~(|y[62:52]) && |y[51:0]) $fwrite(fp, "ydenorm "); - if(~(|z[62:52]) && |z[51:0]) $fwrite(fp, "zdenorm "); - if(invalid != 0) $fwrite(fp, "invld "); - if(overflow != 0) $fwrite(fp, "ovrflw "); - if(underflow != 0) $fwrite(fp, "unflw "); - if(w == 64'hFFF0000000000000) $fwrite(fp, "w=-inf "); - if(w == 64'h7FF0000000000000) $fwrite(fp, "w=+inf "); - if(w > 64'h7FF0000000000000 && w < 64'h7FF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w > 64'hFFF8000000000000 && w < 64'hFFF8000000000000 ) $fwrite(fp, "w=sigNaN "); - if(w >= 64'h7FF8000000000000 && w <= 64'h7FFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(w >= 64'hFFF8000000000000 && w <= 64'hFFFfffffffffffff ) $fwrite(fp, "w=qutNaN "); - if(ans == 64'hFFF0000000000000) $fwrite(fp, "ans=-inf "); - if(ans == 64'h7FF0000000000000) $fwrite(fp, "ans=+inf "); - if(ans > 64'h7FF0000000000000 && ans < 64'h7FF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans > 64'hFFF8000000000000 && ans < 64'hFFF8000000000000 ) $fwrite(fp, "ans=sigNaN "); - if(ans >= 64'h7FF8000000000000 && ans <= 64'h7FFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - if(ans >= 64'hFFF8000000000000 && ans <= 64'hFFFfffffffffffff ) $fwrite(fp, "ans=qutNaN "); - $fwrite(fp,"6015817\n"); end $stop; end